home *** CD-ROM | disk | FTP | other *** search
/ Beginning Mac Programming / Beginning Mac Programming.bin / pc / Open Me for REALbasic 3 / REALbasic 3.2 / Goodies / REAL Software / REALbasic Plug-ins SDK / Examples / obsolete / QTplugin / QTPlugin.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-03-23  |  59.9 KB  |  2,016 lines
  1. #include "rb_plugin.h"
  2. #include <Movies.h>
  3. #include <QuicktimeComponents.h>
  4. #include "QTEffect.h"
  5.  
  6. static double playerGetPosition(REALmoviePlayer instance, long param);
  7. static void playerSetPosition(REALmoviePlayer instance, long param, double value);
  8. static int movieTrackCount(REALobject instance, long param);
  9. static REALpicture moviePictureGetter(REALobject instance, long param);
  10. static REALpicture moviePosterGetter(REALobject instance, long param);
  11. static void moviePosterSetter(REALobject instance, long param, REALpicture value);
  12.  
  13. static REALobject movieTrack(REALobject instance, int index);
  14. static REALobject newVideoTrack(REALobject movie, int width, int height, int frameRate);
  15. static REALobject newSoundTrack(REALobject movie, int frameRate);
  16. static double trackGetDuration(REALobject instance, long param);
  17. static unsigned long trackGetEnabled(REALobject instance, long param);
  18. static void trackSetEnabled(REALobject instance, long param, unsigned long value);
  19. static REALpicture effectSequenceImageGetter(REALobject instance, long param);
  20. static REALobject getQTSMPTEEffect(int wipeId);
  21. static REALobject getQTCrossFadeEffect(void);
  22. static void newQTEffectSequence(REALobject object, REALobject effect, REALpicture pic1, REALpicture pic2, int frames);
  23. static REALobject createMovie(REALfolderItem location);
  24. static REALobject openAsEditableMovie(REALfolderItem location);
  25. static void videoTrackAppendPicture(REALobject track, REALpicture pic);
  26. static int videoTrackSelectCompression(REALobject videoTrack);
  27. static void trackDestructor(REALobject track, void *garbage);
  28. static void videoTrackDestructor(REALobject track, void *garbage);
  29. static void soundTrackDestructor(REALobject track, void *garbage);
  30. static void qtEffectDestructor(REALobject object, void *crud);
  31. static void qtEffectSequenceDestructor(REALobject object, void *crud);
  32. static void editableMovieDestructor(REALobject instance, void *garbage);
  33. static void soundTrackAppendSound(REALobject track, REALsound snd);
  34. static int soundTrackSelectCompression(REALobject soundTrack);
  35.  
  36. static double moviePositionGetter(REALobject instance, long param);
  37. static void moviePositionSetter(REALobject instance, long param, double value);
  38. static double movieDurationGetter(REALobject instance, long param);
  39. static int movieEOFGetter(REALobject instance, long param);
  40.  
  41. static int movieTimeScaleGetter(REALobject instance, long param);
  42. static void movieTimeScaleSetter(REALobject instance, long param, int value);
  43. static int movieTimeValueGetter(REALobject instance, long param);
  44. static void movieTimeValueSetter(REALobject instance, long param, int value);
  45. static int movieTimeDurationGetter(REALobject instance, long param);
  46. static int movieDataSize(REALobject instance, long start, long duration);
  47. static int trackDataSize(REALobject instance, long start, long duration);
  48. static REALobject movieUserDataGetter(REALobject instance, long param);
  49.  
  50. static int userDataGetCount(REALobject instance, REALstring udType);
  51. static int userDataGetUserData(REALobject instance, REALstring udType, int index, REALstring *pvalue);
  52. static void userDataAddUserData(REALobject instance, REALstring udType, REALstring value);
  53. static void userDataRemoveUserData(REALobject instance, REALstring udType, int index);
  54. static int userDataAlternateUserDataGetter(REALobject instance, REALstring udType, int index, REALstring *pvalue, int region);
  55. static void userDataAlternateUserDataSetter(REALobject instance, REALstring udType, int index, REALstring value, int region);
  56.  
  57. static int trackTrackOffsetGetter(REALobject instance, long param);
  58. static void trackTrackOffsetSetter(REALobject instance, long param, int value);
  59. static int trackTimeScaleGetter(REALobject instance, long param);
  60. static void trackTimeScaleSetter(REALobject instance, long param, int value);
  61. static int trackTimeDurationGetter(REALobject instance, long param);
  62. static int trackIDGetter(REALobject instance, long param);
  63.  
  64. static void trackFirstSample(REALobject track);
  65. static void trackNextSample(REALobject track);
  66. static void trackFirstSync(REALobject track);
  67. static void trackNextSync(REALobject track);
  68. static REALstring trackMediaType(REALobject track, long param);
  69.  
  70. static double soundFormatRateGetter(REALobject instance, long param);
  71. static void soundFormatRateSetter(REALobject instance, long param, double value);
  72. static int soundFormatSampleSizeGetter(REALobject instance, long param);
  73. static void soundFormatSampleSizeSetter(REALobject instance, long param, int value);
  74. static int soundFormatChannelCountGetter(REALobject instance, long param);
  75. static void soundFormatChannelCountSetter(REALobject instance, long param, int value);
  76. static REALstring soundFormatCompressionGetter(REALobject instance, long param);
  77. static void soundFormatCompressionSetter(REALobject instance, long param, REALstring value);
  78. static int soundFormatSelectSettings(REALobject instance);
  79. static void soundFormatConstructor(REALobject instance, double rate, int sampleSize, int channelCount, REALstring compression);
  80. static REALobject getSoundConverter(REALobject inputFormat, REALobject outputFormat);
  81. static REALobject soundSampleFormatGetter(REALsound instance, long param);
  82. static REALstring soundSamplesGetter(REALsound instance, long param);
  83.  
  84. static int soundFormatSamplesPerPacket(REALobject instance, long param);
  85. static int soundFormatBytesPerSample(REALobject instance, long param);
  86. static int soundFormatBytesPerFrame(REALobject instance, long param);
  87. static int soundFormatBytesPerPacket(REALobject instance, long param);
  88.  
  89. static REALobject getQTGraphicsExporter(REALstring format);
  90. static void graphicsExporterDestructor(REALobject instance, long dummy);
  91. static int graphicsExporterRequestSettings(REALobject instance);
  92. static int graphicsExporterHasSettingsDialogGetter(REALobject instance, long param);
  93. static REALstring graphicsExporterDefaultExtensionGetter(REALobject instance, long param);
  94. static REALstring graphicsExporterSettingsDescriptionGetter(REALobject instance, long param);
  95. static int graphicsExporterSavePicture(REALobject instance, REALfolderItem location, REALpicture image);
  96. static int graphicsExporterDesiredTargetDataSizeGetter(REALobject instance, long param);
  97. static void graphicsExporterDesiredTargetDataSizeSetter(REALobject instance, long param, int value);
  98. static int graphicsExporterCompressionQualityGetter(REALobject instance, long param);
  99. static void graphicsExporterCompressionQualitySetter(REALobject instance, long param, int value);
  100. static REALstring graphicsExporterOutputFileTypeGetter(REALobject instance, long param);
  101. static void graphicsExporterOutputFileTypeSetter(REALobject instance, long param, REALstring value);
  102. static REALstring graphicsExporterOutputFileCreatorGetter(REALobject instance, long param);
  103. static void graphicsExporterOutputFileCreatorSetter(REALobject instance, long param, REALstring value);
  104.  
  105. static Boolean gQuicktime21Installed, gQuicktime30Installed;
  106.  
  107. REALproperty playerProperties[1] = {
  108.     { nil, "Position", "Double", 0, (REALproc) playerGetPosition, (REALproc) playerSetPosition },
  109. };
  110.  
  111. REALproperty movieProperties[] = {
  112.     { nil, "TrackCount", "Integer", 0, (REALproc) movieTrackCount },
  113.     { nil, "Position", "Double", 0, (REALproc) moviePositionGetter, (REALproc) moviePositionSetter },
  114.     { nil, "Duration", "Double", 0, (REALproc) movieDurationGetter },
  115.     { nil, "EOF", "Boolean", 0, (REALproc) movieEOFGetter },
  116.     { nil, "Picture", "Picture", 0, (REALproc) moviePictureGetter },
  117.     { nil, "Poster", "Picture", 0, (REALproc) moviePosterGetter },
  118.     { nil, "UserData", "QTUserData", 0, (REALproc) movieUserDataGetter },
  119.  
  120.     { nil, "TimeScale", "Integer", 0, (REALproc) movieTimeScaleGetter, (REALproc) movieTimeScaleSetter },
  121.     { nil, "TimeValue", "Integer", 0, (REALproc) movieTimeValueGetter, (REALproc) movieTimeValueSetter },
  122.     { nil, "TimeDuration", "Integer", 0, (REALproc) movieTimeDurationGetter },
  123. };
  124.  
  125. REALproperty soundProperties[] = {
  126.     { nil, "SampleFormat", "SoundFormat", 0, (REALproc) soundSampleFormatGetter },
  127.     { nil, "Samples", "String", 0, (REALproc) soundSamplesGetter },
  128. };
  129.  
  130. REALmethodDefinition movieMethods[] = {
  131.     { (REALproc) movieTrack, REALnoImplementation, "Track(index as integer) As QTTrack"},
  132.     { (REALproc) newVideoTrack, REALnoImplementation, "NewVideoTrack(width as integer, height as integer, timeScale as integer) As QTVideoTrack" },
  133. //    { (REALproc) newSoundTrack, REALnoImplementation, "NewSoundTrack(timeScale as integer) As QTSoundTrack" },
  134.     { (REALproc) movieDataSize, REALnoImplementation, "DataSize(startTime as integer, durationTime As Integer) As Integer" },
  135. };
  136.  
  137. REALmethodDefinition userDataMethods[] = {
  138.     { (REALproc) userDataGetCount, REALnoImplementation, "UserDataCount(udType As string) As Integer" },
  139.     { (REALproc) userDataGetUserData, REALnoImplementation, "GetUserData(udType As string, index As Integer, ByRef value As string) As Boolean" },
  140.     { (REALproc) userDataAddUserData, REALnoImplementation, "AddUserData(udType As string, value As string)" },
  141.     { (REALproc) userDataRemoveUserData, REALnoImplementation, "RemoveUserData(udType As string, index As Integer)" },
  142.     { (REALproc) userDataAlternateUserDataGetter, REALnoImplementation, "GetUserDataText(udType As string, index As Integer, ByRef value As string, region As Integer) As Boolean" },
  143.     { (REALproc) userDataAlternateUserDataSetter, REALnoImplementation, "SetUserDataText(udType As string, index As Integer, value As string, region As Integer)" },
  144. };
  145.  
  146. REALproperty trackProperties[] = {
  147.     { nil, "Duration", "Double", 0, (REALproc) trackGetDuration },
  148.     { nil, "Enabled", "Boolean", 0, (REALproc) trackGetEnabled, (REALproc) trackSetEnabled },
  149.     { nil, "MediaType", "String", 0, (REALproc) trackMediaType },
  150.     { nil, "TrackOffset", "Integer", 0, (REALproc) trackTrackOffsetGetter, (REALproc) trackTrackOffsetSetter },
  151.  
  152.     { nil, "TimeScale", "Integer", 0, (REALproc) trackTimeScaleGetter, (REALproc) trackTimeScaleSetter },
  153.     { nil, "TimeDuration", "Integer", 0, (REALproc) trackTimeDurationGetter },
  154.     { nil, "TrackID", "Integer", 0, (REALproc) trackIDGetter },
  155. };
  156.  
  157. REALproperty effectSequenceProperties[] = {
  158.     { nil, "Image", "Picture", 0, (REALproc) effectSequenceImageGetter },
  159.     { nil, "Frame", "Integer", 0, REALstandardGetter, REALstandardSetter, FieldOffset(EffectSequenceData, currentFrame) },
  160. };
  161.  
  162. REALproperty soundFormatProperties[] = {
  163.     { nil, "Rate", "Double", 0, (REALproc) soundFormatRateGetter, (REALproc) soundFormatRateSetter },
  164.     { nil, "SampleSize", "Integer", 0, (REALproc) soundFormatSampleSizeGetter, (REALproc) soundFormatSampleSizeSetter },
  165.     { nil, "ChannelCount", "Integer", 0, (REALproc) soundFormatChannelCountGetter, (REALproc) soundFormatChannelCountSetter },
  166.     { nil, "Compression", "String", 0, (REALproc) soundFormatCompressionGetter, (REALproc) soundFormatCompressionSetter },
  167.     { nil, "SamplesPerPacket", "Integer", 0, (REALproc) soundFormatSamplesPerPacket },
  168.     { nil, "BytesPerSample", "Integer", 0, (REALproc) soundFormatBytesPerSample },
  169.     { nil, "BytesPerFrame", "Integer", 0, (REALproc) soundFormatBytesPerFrame },
  170.     { nil, "BytesPerPacket", "Integer", 0, (REALproc) soundFormatBytesPerPacket },
  171. };
  172.  
  173. REALmethodDefinition soundFormatMethods[] = {
  174.     { (REALproc) soundFormatSelectSettings, REALnoImplementation, "SelectSettings As Boolean"},
  175.     { (REALproc) soundFormatConstructor, REALnoImplementation, "SoundFormat(rate As Double, SampleSize As Integer, ChannelCount As Integer, compression As String)"},
  176. };
  177.  
  178. REALmethodDefinition GetQTGraphicsExporterMethod = 
  179.     { (REALproc) getQTGraphicsExporter, REALnoImplementation, "GetQTGraphicsExporter(format as string) As QTGraphicsExporter" };
  180.  
  181. REALmethodDefinition GetQTSMPTEEffectMethod = 
  182.     { (REALproc) getQTSMPTEEffect, REALnoImplementation, "GetQTSMPTEEffect(Id as integer) As QTEffect" };
  183.  
  184. REALmethodDefinition GetQTCrossFadeEffectMethod = 
  185.     { (REALproc) getQTCrossFadeEffect, REALnoImplementation, "GetQTCrossFadeEffect As QTEffect" };
  186.  
  187. REALmethodDefinition GetSoundConverterMethod = 
  188.     { (REALproc) getSoundConverter, REALnoImplementation, "GetSoundConverter(inputFormat As SoundFormat, outputFormat As SoundFormat) As SoundConverter" };
  189.  
  190. REALmethodDefinition effectSequenceMethods[1] = {
  191.     { (REALproc) newQTEffectSequence, REALnoImplementation, "QTEffectSequence(effect as QTEffect, image1 as Picture, image2 as Picture, frames as integer)" },
  192. };
  193.  
  194. REALmethodDefinition folderItemMethods[2] = {
  195.     { (REALproc) createMovie, REALnoImplementation, "CreateMovie As EditableMovie" },
  196.     { (REALproc) openAsEditableMovie, REALnoImplementation, "OpenEditableMovie As EditableMovie" },
  197. };
  198.  
  199. REALproperty graphicsExporterProperties[] = {
  200.     { nil, "HasSettingsDialog", "Boolean", 0, (REALproc) graphicsExporterHasSettingsDialogGetter },
  201.     { nil, "DefaultExtension", "String", 0, (REALproc) graphicsExporterDefaultExtensionGetter },
  202.     { nil, "SettingsDescription", "String", 0, (REALproc) graphicsExporterSettingsDescriptionGetter },
  203.     { nil, "DesiredTargetDataSize", "Integer", 0, (REALproc) graphicsExporterDesiredTargetDataSizeGetter, (REALproc) graphicsExporterDesiredTargetDataSizeSetter },
  204.     { nil, "CompressionQuality", "Integer", 0, (REALproc) graphicsExporterCompressionQualityGetter, (REALproc) graphicsExporterCompressionQualitySetter },
  205.     { nil, "OutputFileType", "String", 0, (REALproc) graphicsExporterOutputFileTypeGetter, (REALproc) graphicsExporterOutputFileTypeSetter },
  206.     { nil, "OutputFileCreator", "String", 0, (REALproc) graphicsExporterOutputFileCreatorGetter, (REALproc) graphicsExporterOutputFileCreatorSetter },
  207. };
  208.  
  209. REALmethodDefinition graphicsExporterMethods[2] = {
  210.     { (REALproc) graphicsExporterRequestSettings, REALnoImplementation, "RequestSettings As Boolean" },
  211.     { (REALproc) graphicsExporterSavePicture, REALnoImplementation, "SavePicture(location As FolderItem, image As Picture) As Boolean" },
  212. };
  213.  
  214. REALmethodDefinition trackMethods[] = {
  215.     { (REALproc) trackFirstSample, REALnoImplementation, "FindFirstSample" },
  216.     { (REALproc) trackNextSample, REALnoImplementation, "FindNextSample" },
  217.     { (REALproc) trackFirstSync, REALnoImplementation, "FindFirstKeyFrame" },
  218.     { (REALproc) trackNextSync, REALnoImplementation, "FindNextKeyFrame" },
  219.     { (REALproc) trackDataSize, REALnoImplementation, "DataSize(startTime as integer, durationTime As Integer) As Integer" },
  220. };
  221.  
  222. REALmethodDefinition videoTrackMethods[] = {
  223.     { (REALproc) videoTrackAppendPicture, REALnoImplementation, "AppendPicture(pic As Picture)"},
  224.     { (REALproc) videoTrackSelectCompression, REALnoImplementation, "SelectCompressionSettings As Boolean" },
  225. };
  226.  
  227. REALmethodDefinition soundConverterMethods[] = {
  228.     { (REALproc) videoTrackAppendPicture, REALnoImplementation, "Convert(samples As String) As String"},
  229. };
  230.  
  231. /*
  232. REALmethodDefinition soundTrackMethods[] = {
  233.     { (REALproc) soundTrackAppendSound, REALnoImplementation, "AppendSound(snd As Sound)"},
  234.     { (REALproc) soundTrackSelectCompression, REALnoImplementation, "SelectCompressionSettings As Boolean" },
  235. };
  236. */
  237.  
  238. struct EditableMovieData
  239. {
  240.     Movie aMovie;
  241.     short resRefNum, resId;
  242.     Boolean bDirty, bNew;
  243.     TimeValue currentTime;
  244. };
  245.  
  246. struct QTUserDataData
  247. {
  248.     UserData data;
  249. };
  250.  
  251. struct QTGraphicsExporterData
  252. {
  253.     GraphicsExportComponent component;
  254.     
  255. };
  256.  
  257. REALclassDefinition playerExtension = {
  258.     kCurrentREALControlVersion,
  259.     "MoviePlayer",
  260.     nil,
  261.     0,
  262.     0,
  263.     nil,
  264.     nil,
  265.     playerProperties,
  266.     1,
  267.     nil,
  268.     0,
  269.     nil,
  270.     0,
  271. };
  272.  
  273. REALclassDefinition editableMovieClass = {
  274.     kCurrentREALControlVersion,
  275.     "EditableMovie",
  276.     nil,
  277.     sizeof(EditableMovieData),
  278.     0,
  279.     nil,
  280.     (REALproc) editableMovieDestructor,
  281.     movieProperties,
  282.     sizeof(movieProperties) / sizeof(REALproperty),
  283.     movieMethods,
  284.     sizeof(movieMethods) / sizeof(REALmethodDefinition),
  285.     nil,
  286.     0,
  287. };
  288.  
  289. REALclassDefinition qtUserDataClass = {
  290.     kCurrentREALControlVersion,
  291.     "QTUserData",
  292.     nil,
  293.     sizeof(QTUserDataData),
  294.     0,
  295.     nil,
  296.     nil,
  297.     nil,
  298.     0,
  299.     userDataMethods,
  300.     sizeof(userDataMethods) / sizeof(REALmethodDefinition),
  301.     nil,
  302.     0,
  303. };
  304.  
  305. REALclassDefinition folderItemExtension = {
  306.     kCurrentREALControlVersion,
  307.     "FolderItem",
  308.     nil,
  309.     0,
  310.     0,
  311.     nil,
  312.     nil,
  313.     nil,
  314.     0,
  315.     folderItemMethods,
  316.     sizeof(folderItemMethods) / sizeof(REALmethodDefinition),
  317.     nil,
  318.     0,
  319. };
  320.  
  321. REALclassDefinition qtGraphicsExporterClass = {
  322.     kCurrentREALControlVersion,
  323.     "QTGraphicsExporter",
  324.     nil,
  325.     sizeof(QTGraphicsExporterData),
  326.     0,
  327.     nil,
  328.     (REALproc) graphicsExporterDestructor,
  329.     graphicsExporterProperties,
  330.     sizeof(graphicsExporterProperties) / sizeof(REALproperty),
  331.     graphicsExporterMethods,
  332.     sizeof(graphicsExporterMethods) / sizeof(REALmethodDefinition),
  333.     nil,
  334.     0,
  335. };
  336.  
  337. struct TrackData
  338. {
  339.     Track theTrack;
  340.  
  341.     REALobject movie;
  342. };
  343.  
  344. struct VideoTrackData
  345. {
  346.     Boolean bEdits;
  347.     TimeValue oldDuration;
  348.  
  349.     Fixed frameRate;
  350.  
  351.     Boolean bCodecSelected;
  352.     short codecDepth;
  353.     CodecQ codecQuality;
  354.     CodecQ temporalQuality;
  355.     CodecType cType;
  356.     CompressorComponent codec;
  357.     int keyFrameRate;
  358.  
  359.     ComponentInstance standardCompressor;
  360.  
  361.     Boolean bCompressorPrepared;
  362.     long maxSize;
  363.     Handle bits;
  364.     GWorldPtr compressionPage;
  365.     ImageSequence seq;
  366.     ImageDescription **imageDescriptionH;
  367.  
  368.     Boolean bFirstFrame;
  369. };
  370. /*
  371. struct SoundTrackData
  372. {
  373.     Boolean bEdits;
  374.     TimeValue oldDuration;
  375.  
  376.     UnsignedFixed rate;
  377.     short sSize, cCount;
  378.     OSType compType;
  379. };
  380. */
  381. REALclassDefinition trackClass = {
  382.     kCurrentREALControlVersion,
  383.     "QTTrack",
  384.     nil,
  385.     sizeof(TrackData),
  386.     0,
  387.     nil,
  388.     (REALproc) trackDestructor,
  389.     trackProperties,
  390.     sizeof(trackProperties) / sizeof(REALproperty),
  391.     trackMethods,
  392.     sizeof(trackMethods) / sizeof(REALmethodDefinition),
  393.     nil,
  394.     0,
  395. };
  396.  
  397. REALclassDefinition videoTrackClass = {
  398.     kCurrentREALControlVersion,
  399.     "QTVideoTrack",
  400.     "QTTrack",
  401.     sizeof(VideoTrackData),
  402.     0,
  403.     nil,
  404.     (REALproc) videoTrackDestructor,
  405.     nil,
  406.     0,
  407.     videoTrackMethods,
  408.     sizeof(videoTrackMethods) / sizeof(REALmethodDefinition),
  409.     nil,
  410.     0,
  411. };
  412.  
  413. struct SoundFormatData
  414. {
  415.     UnsignedFixed rate;
  416.     short sSize, cCount;
  417.     OSType compType;
  418. };
  419.  
  420. REALclassDefinition soundExtension = {
  421.     kCurrentREALControlVersion,
  422.     "Sound",
  423.     nil,
  424.     0,
  425.     0,
  426.     nil,
  427.     nil,
  428.     soundProperties,
  429.     sizeof(soundProperties) / sizeof(REALproperty),
  430.     nil,
  431.     0,
  432.     nil,
  433.     0,
  434. };
  435.  
  436. REALclassDefinition soundFormatClass = {
  437.     kCurrentREALControlVersion,
  438.     "SoundFormat",
  439.     nil,
  440.     sizeof(SoundFormatData),
  441.     0,
  442.     nil,
  443.     nil,
  444.     soundFormatProperties,
  445.     sizeof(soundFormatProperties) / sizeof(REALproperty),
  446.     soundFormatMethods,
  447.     sizeof(soundFormatMethods) / sizeof(REALmethodDefinition),
  448.     nil,
  449.     0,
  450. };
  451.  
  452. struct SoundConverterData
  453. {
  454.     SoundConverter sc;
  455.     CompressionInfo ici, oci;
  456.     unsigned long maxInputFrames, inputBytes, outputBytes;
  457. };
  458.  
  459. REALclassDefinition soundConverterClass = {
  460.     kCurrentREALControlVersion,
  461.     "SoundConverter",
  462.     nil,
  463.     sizeof(SoundConverterData),
  464.     0,
  465.     nil,
  466.     nil,
  467.     nil,
  468.     0,
  469.     soundConverterMethods,
  470.     sizeof(soundConverterMethods) / sizeof(REALmethodDefinition),
  471.     nil,
  472.     0,
  473. };
  474.  
  475. /*
  476. REALclassDefinition soundTrackClass = {
  477.     kCurrentREALControlVersion,
  478.     "QTSoundTrack",
  479.     "QTTrack",
  480.     sizeof(SoundTrackData),
  481.     0,
  482.     nil,
  483.     nil,
  484.     nil,
  485.     0,
  486.     soundTrackMethods,
  487.     sizeof(soundTrackMethods) / sizeof(REALmethodDefinition),
  488.     nil,
  489.     0,
  490. };
  491. */
  492. REALclassDefinition qteffectClass = {
  493.     kCurrentREALControlVersion,
  494.     "QTEffect",
  495.     nil,
  496.     sizeof(EffectData),
  497.     0,
  498.     nil,
  499.     (REALproc) qtEffectDestructor,
  500.     nil,
  501.     0,
  502.     nil,
  503.     0,
  504.     nil,
  505.     0
  506. };
  507.  
  508. REALclassDefinition qteffectSequenceClass = {
  509.     kCurrentREALControlVersion,
  510.     "QTEffectSequence",
  511.     nil,
  512.     sizeof(EffectSequenceData),
  513.     0,
  514.     nil,
  515.     (REALproc) qtEffectSequenceDestructor,
  516.     effectSequenceProperties,
  517.     sizeof(effectSequenceProperties) / sizeof(REALproperty),
  518.     effectSequenceMethods,
  519.     sizeof(effectSequenceMethods) / sizeof(REALmethodDefinition),
  520.     nil,
  521.     0
  522. };
  523.  
  524. static double playerGetPosition(REALmoviePlayer instance, long param)
  525. {
  526.     TimeScale scale;
  527.     float f;
  528.  
  529.     scale = 1000;
  530.     f = MCGetCurrentTime(REALgetMoviePlayerController(instance), &scale);
  531.     f = f / scale;
  532.     return f;
  533. }
  534.  
  535. static void playerSetPosition(REALmoviePlayer instance, long param, double value)
  536. {
  537.     TimeRecord timeSpec;
  538.     Movie movie;
  539.     MovieController ctl = REALgetMoviePlayerController(instance);
  540.  
  541.     if (!ctl)
  542.         return;
  543.     movie = MCGetMovie(ctl);
  544.     if (!movie)
  545.         return;
  546.  
  547.     if (value < 0.0)
  548.         value = 0.0;
  549.     timeSpec.scale = GetMovieTimeScale(movie);
  550.     value = value * timeSpec.scale;
  551.     timeSpec.value.lo = value;
  552.     timeSpec.value.hi = 0;
  553.     timeSpec.base = GetMovieTimeBase(movie);
  554.  
  555.     MCDoAction(ctl, mcActionGoToTime, &timeSpec);
  556. }
  557.  
  558. static int movieTrackCount(REALobject instance, long param)
  559. {
  560.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  561.  
  562.     return GetMovieTrackCount(data->aMovie);
  563. }
  564.  
  565. static REALobject movieTrack(REALobject instance, int index)
  566. {
  567.     ClassData(editableMovieClass, instance, EditableMovieData, mdata);
  568.     Track t = GetMovieIndTrack(mdata->aMovie, index);
  569.     REALobject rv;
  570.  
  571.     if (!t)
  572.         return nil;
  573.     rv = REALnewInstance("QTTrack");    
  574.     if (rv)
  575.     {
  576.         ClassData(trackClass, rv, TrackData, data);
  577.         data->theTrack = t;
  578.         data->movie = instance;
  579.         REALLockObject(data->movie);
  580.     }
  581.     return rv;
  582. }
  583.  
  584. static double trackGetDuration(REALobject instance, long param)
  585. {
  586.     ClassData(trackClass, instance, TrackData, data);
  587.  
  588.     double v = GetTrackDuration(data->theTrack);
  589.     v = v / GetMovieTimeScale(GetTrackMovie(data->theTrack));
  590.     return v;
  591. }
  592.  
  593. static unsigned long trackGetEnabled(REALobject instance, long param)
  594. {
  595.     ClassData(trackClass, instance, TrackData, data);
  596.  
  597.     if (GetTrackEnabled(data->theTrack))
  598.         return 1;
  599.     else
  600.         return 0;
  601. }
  602.  
  603. static void trackSetEnabled(REALobject instance, long param, unsigned long value)
  604. {
  605.     ClassData(trackClass, instance, TrackData, data);
  606.  
  607.     SetTrackEnabled(data->theTrack, value != 0);
  608. }
  609.  
  610. static REALpicture effectSequenceImageGetter(REALobject instance, long param)
  611. {
  612.     ClassData(qteffectSequenceClass, instance, EffectSequenceData, data);
  613.  
  614.     if (data->lastFrame != data->currentFrame)
  615.     {
  616.         BuildEffectSequenceFrame(data, data->currentFrame);
  617.         data->lastFrame = data->currentFrame;
  618.     }
  619.  
  620.     REALLockObject((REALobject) data->destPicture);
  621.     return data->destPicture;
  622. }
  623.  
  624. static REALobject getQTSMPTEEffect(int wipeId)
  625. {
  626.     REALobject rv;
  627.  
  628.     if (!gQuicktime30Installed)
  629.         return nil;
  630.  
  631.     if (!REALenterMovies())
  632.         return nil;
  633.  
  634.     rv = REALnewInstance("QTEffect");    
  635.     if (rv)
  636.     {
  637.         ClassData(qteffectClass, rv, EffectData, data);
  638.         BuildSMPTEEffect(data, wipeId);
  639.     }
  640.     return rv;
  641. }
  642.  
  643. static REALobject getQTCrossFadeEffect(void)
  644. {
  645.     REALobject rv;
  646.  
  647.     if (!gQuicktime30Installed)
  648.         return nil;
  649.  
  650.     if (!REALenterMovies())
  651.         return nil;
  652.  
  653.     rv = REALnewInstance("QTEffect");    
  654.     if (rv)
  655.     {
  656.         ClassData(qteffectClass, rv, EffectData, data);
  657.         BuildCrossFadeEffect(data);
  658.     }
  659.  
  660.     return rv;
  661. }
  662.  
  663. static void newQTEffectSequence(REALobject object, REALobject effect, REALpicture pic1, REALpicture pic2, int frames)
  664. {
  665.     if (!gQuicktime30Installed)
  666.         return;
  667.  
  668.     if (!REALenterMovies())
  669.         return;
  670.     
  671.     if (effect)
  672.     {
  673.         ClassData(qteffectSequenceClass, object, EffectSequenceData, data);
  674.         ClassData(qteffectClass, effect, EffectData, effectData);
  675.         if (effectData->theEffectType)
  676.             BuildEffectSquence(data, effectData, pic1, pic2, frames);
  677.     }
  678. }
  679.  
  680. static void qtEffectDestructor(REALobject object, void *crud)
  681. {
  682.     ClassData(qteffectClass, object, EffectData, effectData);
  683.  
  684.     if (effectData->fEffectDescription)
  685.         QTDisposeAtomContainer(effectData->fEffectDescription);
  686. }
  687.  
  688. static void qtEffectSequenceDestructor(REALobject object, void *crud)
  689. {
  690.     ClassData(qteffectSequenceClass, object, EffectSequenceData, data);
  691.  
  692.     if (data->fEffectSequenceID != 0L)
  693.         CDSequenceEnd(data->fEffectSequenceID);
  694.  
  695.     if (data->fEffectDescription)
  696.         QTDisposeAtomContainer(data->fEffectDescription);
  697.     if (data->pic1)
  698.     {
  699.         REALUnlockPictureDescription(data->pic1);
  700.         REALUnlockObject((REALobject) data->pic1);
  701.     }
  702.     else if (data->fGW1)
  703.         DisposeGWorld(data->fGW1);
  704.     if (data->pic2)
  705.     {
  706.         REALUnlockPictureDescription(data->pic2);
  707.         REALUnlockObject((REALobject) data->pic2);
  708.     }
  709.     else if (data->fGW2)
  710.         DisposeGWorld(data->fGW2);
  711.  
  712.     if (data->destPicture)
  713.         REALUnlockObject((REALobject) data->destPicture);
  714.  
  715.     if (data->fSampleDescription)
  716.         DisposeHandle((Handle) data->fSampleDescription);
  717. }
  718.  
  719. static REALobject createMovie(REALfolderItem location)
  720. {
  721.     FSSpec spec;
  722.     short resRefNum;
  723.     Movie aMovie;
  724.     REALobject newMovie;
  725.  
  726.     if (!REALenterMovies())
  727.         return nil;
  728.  
  729.     if (!REALFSSpecFromFolderItem(&spec, location))
  730.         return nil;
  731.  
  732.     if (noErr != CreateMovieFile(&spec, 'TVOD', 0, createMovieFileDeleteCurFile | newMovieActive, &resRefNum, &aMovie))
  733.         return nil;
  734.  
  735.     newMovie = REALnewInstance("editableMovie");
  736.     ClassData(editableMovieClass, newMovie, EditableMovieData, data);
  737.     data->aMovie = aMovie;
  738.     data->resRefNum = resRefNum;
  739.     data->bDirty = true;
  740.     data->bNew = true;
  741.  
  742.     return newMovie;
  743. }
  744.  
  745. static REALobject openAsEditableMovie(REALfolderItem location)
  746. {
  747.     FSSpec spec;
  748.     short resRefNum, movieResID;
  749.     Movie aMovie;
  750.     REALobject newMovie;
  751.     OSErr err;
  752.  
  753.     movieResID = 0;
  754.     resRefNum = 0;
  755.  
  756.     if (!REALenterMovies())
  757.         return nil;
  758.  
  759.     if (!REALFSSpecFromFolderItem(&spec, location))
  760.         return nil;
  761.  
  762.     if (noErr != OpenMovieFile(&spec, &resRefNum, fsRdPerm))
  763.         return nil;
  764.     err = NewMovieFromFile(&aMovie, resRefNum,
  765.                             &movieResID, nil, newMovieActive, nil);
  766.     if (noErr != err)
  767.         return nil;
  768.  
  769.     newMovie = REALnewInstance("editableMovie");
  770.     ClassData(editableMovieClass, newMovie, EditableMovieData, data);
  771.     data->aMovie = aMovie;
  772.     data->resRefNum = resRefNum;
  773.     data->resId = movieResID;
  774.     data->bDirty = true;
  775.     data->bNew = false;
  776.     return newMovie;
  777. }
  778.  
  779. static void editableMovieDestructor(REALobject instance, void *garbage)
  780. {
  781.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  782.     short resId = 0;
  783.  
  784.     if (data->bNew)
  785.         AddMovieResource(data->aMovie, data->resRefNum, &resId, nil);
  786.     else if (data->bDirty)
  787.         UpdateMovieResource(data->aMovie, data->resRefNum, data->resId, nil);
  788.  
  789.     DisposeMovie(data->aMovie);
  790.     if (data->resRefNum)
  791.         CloseMovieFile(data->resRefNum);
  792. }
  793.  
  794. static double moviePositionGetter(REALobject instance, long param)
  795. {
  796.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  797.     double v = data->currentTime;
  798.     v /= GetMovieTimeScale(data->aMovie);
  799.     
  800.     return v;
  801. }
  802.  
  803. static double movieDurationGetter(REALobject instance, long param)
  804. {
  805.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  806.     double v = GetMovieDuration(data->aMovie) / GetMovieTimeScale(data->aMovie);
  807.     
  808.     return v;
  809. }
  810.  
  811. static int movieEOFGetter(REALobject instance, long param)
  812. {
  813.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  814.     if (data->currentTime >= GetMovieDuration(data->aMovie))
  815.         return 1;
  816.     return 0;
  817. }
  818.  
  819. static void moviePositionSetter(REALobject instance, long param, double value)
  820. {
  821.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  822.     long v = value * GetMovieTimeScale(data->aMovie);
  823.     if (v < 0)
  824.         v = 0;
  825.     else if (v > GetMovieDuration(data->aMovie))
  826.         v = GetMovieDuration(data->aMovie);
  827.     data->currentTime = v;
  828. }
  829.  
  830. static void trackFirstSample(REALobject track)
  831. {
  832.     ClassData(trackClass, track, TrackData, trackData);
  833.     ClassData(editableMovieClass, trackData->movie, EditableMovieData, movieData);
  834.     TimeValue theTime = GetMovieDuration(movieData->aMovie);
  835.  
  836.     GetTrackNextInterestingTime(trackData->theTrack, nextTimeMediaSample + nextTimeEdgeOK, 0, fixed1, &theTime, nil);
  837.     if (noErr != GetMoviesError())
  838.         movieData->currentTime = GetMovieDuration(movieData->aMovie);
  839.     else
  840.         movieData->currentTime = theTime;
  841. }
  842.  
  843. static void trackNextSample(REALobject track)
  844. {
  845.     ClassData(trackClass, track, TrackData, trackData);
  846.     ClassData(editableMovieClass, trackData->movie, EditableMovieData, movieData);
  847.     TimeValue theTime = GetMovieDuration(movieData->aMovie);
  848.  
  849.     if (gQuicktime21Installed)
  850.         GetTrackNextInterestingTime(trackData->theTrack, nextTimeStep, movieData->currentTime, fixed1, &theTime, nil);
  851.     else
  852.         GetTrackNextInterestingTime(trackData->theTrack, nextTimeMediaSample, movieData->currentTime, fixed1, &theTime, nil);
  853.     if (noErr != GetMoviesError())
  854.         movieData->currentTime = GetMovieDuration(movieData->aMovie);
  855.     else
  856.         movieData->currentTime = theTime;
  857. }
  858.  
  859. static void trackFirstSync(REALobject track)
  860. {
  861.     ClassData(trackClass, track, TrackData, trackData);
  862.     ClassData(editableMovieClass, trackData->movie, EditableMovieData, movieData);
  863.     TimeValue theTime = GetMovieDuration(movieData->aMovie);
  864.  
  865.     GetTrackNextInterestingTime(trackData->theTrack, nextTimeSyncSample + nextTimeEdgeOK, 0, fixed1, &theTime, nil);
  866.     if (noErr != GetMoviesError())
  867.         movieData->currentTime = GetMovieDuration(movieData->aMovie);
  868.     else
  869.         movieData->currentTime = theTime;
  870. }
  871.  
  872. static void trackNextSync(REALobject track)
  873. {
  874.     ClassData(trackClass, track, TrackData, trackData);
  875.     ClassData(editableMovieClass, trackData->movie, EditableMovieData, movieData);
  876.     TimeValue theTime = GetMovieDuration(movieData->aMovie);
  877.  
  878.     GetTrackNextInterestingTime(trackData->theTrack, nextTimeSyncSample, movieData->currentTime, fixed1, &theTime, nil);
  879.     if (noErr != GetMoviesError())
  880.         movieData->currentTime = GetMovieDuration(movieData->aMovie);
  881.     else
  882.         movieData->currentTime = theTime;
  883. }
  884.  
  885. static REALstring trackMediaType(REALobject track, long param)
  886. {
  887.     ClassData(trackClass, track, TrackData, trackData);
  888.     OSType mediaType;
  889.  
  890.     GetMediaHandlerDescription(GetTrackMedia(trackData->theTrack), &mediaType, nil, nil);
  891.     return REALBuildString((Ptr) &mediaType, 4);
  892. }
  893.  
  894. static REALobject newVideoTrack(REALobject instance, int width, int height, int frameRate)
  895. {
  896.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  897.     Track aTrack = NewMovieTrack(data->aMovie, (long)width << 16, (long)height << 16, 0);
  898.     REALobject rv;
  899.  
  900.     if (!aTrack)
  901.         return nil;
  902.  
  903.     Media aMedia = NewTrackMedia(aTrack, VideoMediaType, frameRate, nil, (OSType)nil);
  904.  
  905.     if (!aMedia)
  906.         return nil;
  907.  
  908.     BeginMediaEdits(aMedia);
  909.  
  910.     rv = REALnewInstance("QTVideoTrack");
  911.     if (rv)
  912.     {
  913.         ClassData(trackClass, rv, TrackData, trackData);
  914.         ClassData(videoTrackClass, rv, VideoTrackData, data);
  915.         trackData->theTrack = aTrack;
  916.         trackData->movie = instance;
  917.         REALLockObject(trackData->movie);
  918.         data->bEdits = true;
  919.     }
  920.  
  921.     return rv;
  922. }
  923.  
  924. static void videoTrackAppendPicture(REALobject track, REALpicture pic)
  925. {
  926.     ClassData(trackClass, track, TrackData, trackData);
  927.     ClassData(videoTrackClass, track, VideoTrackData, data);
  928.     Rect r;
  929.     Fixed width, height;
  930.     long compressedFrameSize;
  931.     Media trackMedia = GetTrackMedia(trackData->theTrack);
  932.     CGrafPtr oldPort;
  933.     GDHandle oldDevice;
  934.  
  935.     if (!data->bEdits)
  936.     {
  937.         BeginMediaEdits(trackMedia);
  938.         data->bEdits = true;
  939.         data->oldDuration = GetMediaDuration(trackMedia);
  940.  
  941.         ClassData(editableMovieClass, trackData->movie, EditableMovieData, data);
  942.         data->bDirty = true;
  943.     }
  944.  
  945.     GetTrackDimensions(trackData->theTrack, &width, &height);
  946.     SetRect(&r, 0, 0, width >> 16, height >> 16);
  947.  
  948.     if (data->standardCompressor)
  949.     {
  950.         if (data->bFirstFrame)
  951.         {
  952.             SCSpatialSettings ss;
  953.             SCGetInfo(data->standardCompressor, scSpatialSettingsType, &ss);
  954.             if (ss.depth == 0)
  955.                 ss.depth = 16;
  956.             if (noErr != NewGWorld(&data->compressionPage, ss.depth, &r, nil, nil, 0))
  957.                 NewGWorld(&data->compressionPage, ss.depth, &r, nil, nil, useTempMem);
  958.         }
  959.     }
  960.     else
  961.     {
  962.         if (!data->bCodecSelected)
  963.         {
  964.             data->codecDepth = 16;
  965.             data->codecQuality = codecNormalQuality;
  966.             data->temporalQuality = 0;
  967.             data->cType = 'raw ';
  968.             data->codec = anyCodec;
  969.             data->keyFrameRate = 16;
  970.             data->bCodecSelected = true;
  971.         }
  972.  
  973.         if (!data->bCompressorPrepared)
  974.         {
  975.             if (noErr != NewGWorld(&data->compressionPage, data->codecDepth, &r, nil, nil, 0))
  976.                 NewGWorld(&data->compressionPage, data->codecDepth, &r, nil, nil, useTempMem);
  977.  
  978.             GetMaxCompressionSize(data->compressionPage->portPixMap, &r, data->codecDepth, data->codecQuality, data->cType, data->codec, &data->maxSize);
  979.             data->bCompressorPrepared = true;
  980.             data->bits = NewHandle(data->maxSize);
  981.             data->imageDescriptionH = (ImageDescription **)NewHandle(sizeof(ImageDescription));
  982.  
  983.             data->bFirstFrame = true;
  984.             data->bCompressorPrepared = true;
  985.         }
  986.     }
  987.  
  988.     LockPixels(GetGWorldPixMap(data->compressionPage));
  989.     GetGWorld(&oldPort, &oldDevice);
  990.     SetGWorld(data->compressionPage, nil);
  991.  
  992.     EraseRect(&r);
  993.     if (pic)
  994.         REALDrawPicturePrimitive(pic, &r, false);
  995.  
  996.     OSErr result;
  997.     Handle bits;
  998.  
  999.     if (data->standardCompressor)
  1000.     {
  1001.         short notSyncFlag = 0;
  1002.  
  1003.         if (data->bFirstFrame)
  1004.         {
  1005.             SCCompressSequenceBegin(data->standardCompressor, data->compressionPage->portPixMap, &r, &data->imageDescriptionH);
  1006.             data->bFirstFrame = false;
  1007.         }
  1008.  
  1009.         SCCompressSequenceFrame(data->standardCompressor, data->compressionPage->portPixMap, &r, &bits, &compressedFrameSize, ¬SyncFlag);
  1010.     }
  1011.     else
  1012.     {
  1013.         if (data->bFirstFrame)
  1014.         {
  1015.             result = CompressSequenceBegin(&data->seq, data->compressionPage->portPixMap, nil, &r, nil, data->codecDepth, data->cType, data->codec, data->codecQuality, data->temporalQuality, data->keyFrameRate, nil, codecFlagUpdatePreviousComp, data->imageDescriptionH);
  1016.             data->bFirstFrame = false;
  1017.         }
  1018.  
  1019.         HLock(data->bits);
  1020.         Ptr compressBits = StripAddress(*data->bits);
  1021.  
  1022.         result = CompressSequenceFrame(data->seq, data->compressionPage->portPixMap, &r, codecFlagUpdatePreviousComp, compressBits, &compressedFrameSize, nil, nil);
  1023.         HUnlock(data->bits);
  1024.         bits = data->bits;
  1025.     }
  1026.  
  1027.     SetGWorld(oldPort, oldDevice);
  1028.  
  1029.     UnlockPixels(GetGWorldPixMap(data->compressionPage));
  1030.  
  1031.     result = AddMediaSample(trackMedia, bits, 0L, compressedFrameSize, (TimeValue)1, (SampleDescriptionHandle)data->imageDescriptionH, 1L, 0, nil);
  1032. }
  1033.  
  1034. static void shutdownCurrentVideoCompressor(VideoTrackData *data)
  1035. {
  1036.     if (data->standardCompressor)
  1037.     {
  1038.         if (!data->bFirstFrame)
  1039.             SCCompressSequenceEnd(data->standardCompressor);
  1040.         data->bFirstFrame = true;
  1041.         if (data->compressionPage)
  1042.         {
  1043.             DisposeGWorld(data->compressionPage);
  1044.             data->compressionPage = nil;
  1045.         }
  1046.     }
  1047.     else
  1048.     {
  1049.         if (data->seq)
  1050.         {
  1051.             CDSequenceEnd(data->seq);
  1052.             data->seq = 0;
  1053.         }
  1054.  
  1055.         if (data->bCompressorPrepared)
  1056.         {
  1057.             DisposeHandle((Handle) data->imageDescriptionH);
  1058.             DisposeHandle(data->bits);
  1059.             DisposeGWorld(data->compressionPage);
  1060.             data->bCompressorPrepared = false;
  1061.         }
  1062.     }
  1063. }
  1064.  
  1065. static void videoTrackDestructor(REALobject track, void *garbage)
  1066. {
  1067.     ClassData(videoTrackClass, track, VideoTrackData, data);
  1068.     ClassData(trackClass, track, TrackData, trackData);
  1069.     Media trackMedia = GetTrackMedia(trackData->theTrack);
  1070.  
  1071.     shutdownCurrentVideoCompressor(data);
  1072.  
  1073.     if (data->standardCompressor)
  1074.         CloseComponent(data->standardCompressor);
  1075.  
  1076.     if (data->bEdits)
  1077.     {
  1078.         TimeValue newDuration = GetMediaDuration(trackMedia);
  1079.         if (newDuration > data->oldDuration)
  1080.             InsertMediaIntoTrack(trackData->theTrack, -1, data->oldDuration, newDuration - data->oldDuration, 0x10000);
  1081.         EndMediaEdits(trackMedia);
  1082.     }
  1083. }
  1084. /*
  1085. static void soundTrackDestructor(REALobject track, void *garbage)
  1086. {
  1087.     ClassData(soundTrackClass, track, SoundTrackData, data);
  1088.     ClassData(trackClass, track, TrackData, trackData);
  1089.     Media trackMedia = GetTrackMedia(trackData->theTrack);
  1090.  
  1091.     if (data->bEdits)
  1092.     {
  1093.         TimeValue newDuration = GetMediaDuration(trackMedia);
  1094.         if (newDuration > data->oldDuration)
  1095.             InsertMediaIntoTrack(trackData->theTrack, -1, data->oldDuration, newDuration - data->oldDuration, 0x10000);
  1096.         EndMediaEdits(trackMedia);
  1097.     }
  1098. }
  1099. */
  1100. static void trackDestructor(REALobject track, void *garbage)
  1101. {
  1102.     ClassData(trackClass, track, TrackData, data);
  1103.  
  1104.     REALUnlockObject(data->movie);
  1105. }
  1106.  
  1107. static int videoTrackSelectCompression(REALobject videoTrack)
  1108. {
  1109.     ClassData(videoTrackClass, videoTrack, VideoTrackData, data);
  1110.  
  1111.     shutdownCurrentVideoCompressor(data);
  1112.  
  1113.     if (!data->standardCompressor)
  1114.         data->standardCompressor = OpenDefaultComponent(StandardCompressionType, StandardCompressionSubType);
  1115.     ComponentResult result;
  1116.  
  1117.     if (!data->standardCompressor)
  1118.         return false;
  1119.  
  1120.     result = SCRequestSequenceSettings(data->standardCompressor);
  1121.  
  1122.     if (result < 0 || result == scUserCancelled)
  1123.     {
  1124.         CloseComponent(data->standardCompressor);
  1125.         data->standardCompressor = nil;
  1126.         return false;
  1127.     }
  1128.  
  1129.     data->bFirstFrame = true;
  1130.  
  1131.     return true;
  1132. }
  1133.  
  1134. static REALpicture moviePictureGetter(REALobject instance, long param)
  1135. {
  1136.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  1137.     PicHandle pic;
  1138.  
  1139.     pic = GetMoviePict(data->aMovie, data->currentTime);
  1140.     if (pic)
  1141.         return REALBuildPictureFromPicHandle(pic, true);
  1142.     else
  1143.         return nil;
  1144. }
  1145.  
  1146. static REALpicture moviePosterGetter(REALobject instance, long param)
  1147. {
  1148.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  1149.     PicHandle pic;
  1150.  
  1151.     pic = GetMoviePosterPict(data->aMovie);
  1152.     if (pic)
  1153.         return REALBuildPictureFromPicHandle(pic, true);
  1154.     else
  1155.         return nil;
  1156. }
  1157.  
  1158. static REALobject movieUserDataGetter(REALobject instance, long param)
  1159. {
  1160.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  1161.     REALobject rv = REALnewInstance("QTUserData");
  1162.     ClassData(qtUserDataClass, rv, QTUserDataData, rvdata);
  1163.     rvdata->data = GetMovieUserData(data->aMovie);
  1164.     return rv;
  1165. }
  1166.  
  1167. static int movieTimeScaleGetter(REALobject instance, long param)
  1168. {
  1169.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  1170.  
  1171.     return GetMovieTimeScale(data->aMovie);
  1172. }
  1173.  
  1174. static void movieTimeScaleSetter(REALobject instance, long param, int value)
  1175. {
  1176.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  1177.  
  1178.     SetMovieTimeScale(data->aMovie, value);
  1179. }
  1180.  
  1181. static int movieTimeValueGetter(REALobject instance, long param)
  1182. {
  1183.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  1184.  
  1185.     return data->currentTime;
  1186. }
  1187.  
  1188. static void movieTimeValueSetter(REALobject instance, long param, int value)
  1189. {
  1190.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  1191.  
  1192.     data->currentTime = value;
  1193. }
  1194.  
  1195. static int movieTimeDurationGetter(REALobject instance, long param)
  1196. {
  1197.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  1198.  
  1199.     return GetMovieDuration(data->aMovie);
  1200. }
  1201.  
  1202. static int movieDataSize(REALobject instance, long start, long duration)
  1203. {
  1204.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  1205.  
  1206.     return GetMovieDataSize(data->aMovie, start, duration);
  1207. }
  1208.  
  1209. static int userDataGetCount(REALobject instance, REALstring udType)
  1210. {
  1211.     ClassData(qtUserDataClass, instance, QTUserDataData, data);
  1212.  
  1213.     return CountUserDataType(data->data, REALstringToOSType(udType));
  1214. }
  1215.  
  1216. static int userDataGetUserData(REALobject instance, REALstring udType, int index, REALstring *pvalue)
  1217. {
  1218.     int rv = 0;
  1219.     Handle hData = NewHandle(0);
  1220.     ClassData(qtUserDataClass, instance, QTUserDataData, data);
  1221.  
  1222.     if (noErr == GetUserData(data->data, hData, REALstringToOSType(udType), index))
  1223.     {
  1224.         rv = 1;
  1225.         if (*pvalue)
  1226.             REALUnlockString(*pvalue);
  1227.         HLock(hData);
  1228.         *pvalue = REALBuildString(*hData, GetHandleSize(hData));
  1229.     }
  1230.     DisposeHandle(hData);
  1231.     return rv;
  1232. }
  1233.  
  1234. static void userDataAddUserData(REALobject instance, REALstring udType, REALstring value)
  1235. {
  1236.     Handle hData = NewHandle(0);
  1237.     ClassData(qtUserDataClass, instance, QTUserDataData, data);
  1238.  
  1239.     SetHandleSize(hData, value->Length());
  1240.     BlockMoveData(value->CString(), *hData, value->Length());
  1241.     AddUserData(data->data, hData, REALstringToOSType(udType));
  1242.     DisposeHandle(hData);
  1243. }
  1244.  
  1245. static void userDataRemoveUserData(REALobject instance, REALstring udType, int index)
  1246. {
  1247.     ClassData(qtUserDataClass, instance, QTUserDataData, data);
  1248.  
  1249.     RemoveUserData(data->data, REALstringToOSType(udType), index);
  1250. }
  1251.  
  1252. static int userDataAlternateUserDataGetter(REALobject instance, REALstring udType, int index, REALstring *pvalue, int region)
  1253. {
  1254.     int rv = 0;
  1255.     Handle hData = NewHandle(0);
  1256.     ClassData(qtUserDataClass, instance, QTUserDataData, data);
  1257.  
  1258.     if (noErr == GetUserDataText(data->data, hData, REALstringToOSType(udType), index, region))
  1259.     {
  1260.         rv = 1;
  1261.         if (*pvalue)
  1262.             REALUnlockString(*pvalue);
  1263.         HLock(hData);
  1264.         *pvalue = REALBuildString(*hData, GetHandleSize(hData));
  1265.     }
  1266.     DisposeHandle(hData);
  1267.     return rv;
  1268. }
  1269.  
  1270. static void userDataAlternateUserDataSetter(REALobject instance, REALstring udType, int index, REALstring value, int region)
  1271. {
  1272.     Handle hData = NewHandle(0);
  1273.     ClassData(qtUserDataClass, instance, QTUserDataData, data);
  1274.  
  1275.     SetHandleSize(hData, value->Length());
  1276.     BlockMoveData(value->CString(), *hData, value->Length());
  1277.     AddUserDataText(data->data, hData, REALstringToOSType(udType), index, region);
  1278.     DisposeHandle(hData);
  1279. }
  1280.  
  1281. static int trackDataSize(REALobject instance, long start, long duration)
  1282. {
  1283.     ClassData(trackClass, instance, TrackData, data);
  1284.  
  1285.     return GetTrackDataSize(data->theTrack, start, duration);
  1286. }
  1287.  
  1288. static int trackTrackOffsetGetter(REALobject instance, long param)
  1289. {
  1290.     ClassData(trackClass, instance, TrackData, data);
  1291.  
  1292.     return GetTrackOffset(data->theTrack);
  1293. }
  1294.  
  1295. static void trackTrackOffsetSetter(REALobject instance, long param, int value)
  1296. {
  1297.     ClassData(trackClass, instance, TrackData, data);
  1298.  
  1299.     SetTrackOffset(data->theTrack, value);
  1300. }
  1301.  
  1302. static int trackTimeScaleGetter(REALobject instance, long param)
  1303. {
  1304.     ClassData(trackClass, instance, TrackData, data);
  1305.  
  1306.     return GetMediaTimeScale(GetTrackMedia(data->theTrack));
  1307. }
  1308.  
  1309. static void trackTimeScaleSetter(REALobject instance, long param, int value)
  1310. {
  1311.     ClassData(trackClass, instance, TrackData, data);
  1312.  
  1313.     SetMediaTimeScale(GetTrackMedia(data->theTrack), value);
  1314. }
  1315.  
  1316. static int trackTimeDurationGetter(REALobject instance, long param)
  1317. {
  1318.     ClassData(trackClass, instance, TrackData, data);
  1319.  
  1320.     return GetMediaDuration(GetTrackMedia(data->theTrack));
  1321. }
  1322.  
  1323. static int trackIDGetter(REALobject instance, long param)
  1324. {
  1325.     ClassData(trackClass, instance, TrackData, data);
  1326.     return GetTrackID(data->theTrack);
  1327. }
  1328. /*
  1329. struct SoundFormatData
  1330. {
  1331.     UnsignedFixed rate;
  1332.     short sSize, cCount;
  1333.     OSType compType;
  1334. };
  1335. */
  1336. static double soundFormatRateGetter(REALobject instance, long param)
  1337. {
  1338.     ClassData(soundFormatClass, instance, SoundFormatData, data);
  1339.     double v = data->rate;
  1340.     return v / 65536.0;
  1341. }
  1342.  
  1343. static void soundFormatRateSetter(REALobject instance, long param, double value)
  1344. {
  1345.     ClassData(soundFormatClass, instance, SoundFormatData, data);
  1346.     data->rate = value * 65536.0;
  1347. }
  1348.  
  1349. static int soundFormatSampleSizeGetter(REALobject instance, long param)
  1350. {
  1351.     ClassData(soundFormatClass, instance, SoundFormatData, data);
  1352.  
  1353.     return data->sSize;
  1354. }
  1355.  
  1356. static void soundFormatSampleSizeSetter(REALobject instance, long param, int value)
  1357. {
  1358.     ClassData(soundFormatClass, instance, SoundFormatData, data);
  1359.  
  1360.     data->sSize = value;
  1361. }
  1362.  
  1363. static int soundFormatChannelCountGetter(REALobject instance, long param)
  1364. {
  1365.     ClassData(soundFormatClass, instance, SoundFormatData, data);
  1366.  
  1367.     return data->cCount;
  1368. }
  1369.  
  1370. static void soundFormatChannelCountSetter(REALobject instance, long param, int value)
  1371. {
  1372.     ClassData(soundFormatClass, instance, SoundFormatData, data);
  1373.  
  1374.     data->cCount = value;
  1375. }
  1376.  
  1377. static REALstring soundFormatCompressionGetter(REALobject instance, long param)
  1378. {
  1379.     ClassData(soundFormatClass, instance, SoundFormatData, data);
  1380.  
  1381.     return REALBuildString((Ptr) &data->compType, 4);
  1382. }
  1383.  
  1384. static void soundFormatCompressionSetter(REALobject instance, long param, REALstring value)
  1385. {
  1386.     ClassData(soundFormatClass, instance, SoundFormatData, data);
  1387.  
  1388.     data->compType = REALstringToOSType(value);
  1389. }
  1390.  
  1391. static int soundFormatSamplesPerPacket(REALobject instance, long param)
  1392. {
  1393.     ClassData(soundFormatClass, instance, SoundFormatData, data);
  1394.     CompressionInfo ici;
  1395.  
  1396.     GetCompressionInfo(fixedCompression, data->compType, data->cCount, data->sSize, &ici);
  1397.     return ici.samplesPerPacket;
  1398. }
  1399.  
  1400. static int soundFormatBytesPerSample(REALobject instance, long param)
  1401. {
  1402.     ClassData(soundFormatClass, instance, SoundFormatData, data);
  1403.     CompressionInfo ici;
  1404.  
  1405.     GetCompressionInfo(fixedCompression, data->compType, data->cCount, data->sSize, &ici);
  1406.     return ici.bytesPerSample;
  1407. }
  1408.  
  1409. static int soundFormatBytesPerFrame(REALobject instance, long param)
  1410. {
  1411.     ClassData(soundFormatClass, instance, SoundFormatData, data);
  1412.     CompressionInfo ici;
  1413.  
  1414.     GetCompressionInfo(fixedCompression, data->compType, data->cCount, data->sSize, &ici);
  1415.     return ici.bytesPerFrame;
  1416. }
  1417.  
  1418. static int soundFormatBytesPerPacket(REALobject instance, long param)
  1419. {
  1420.     ClassData(soundFormatClass, instance, SoundFormatData, data);
  1421.     CompressionInfo ici;
  1422.  
  1423.     GetCompressionInfo(fixedCompression, data->compType, data->cCount, data->sSize, &ici);
  1424.     return ici.bytesPerPacket;
  1425. }
  1426.  
  1427. static int soundFormatSelectSettings(REALobject instance)
  1428. {
  1429.     ClassData(soundFormatClass, instance, SoundFormatData, data);
  1430.     ComponentInstance ci;
  1431.     OSErr err;
  1432.     int rv;
  1433.  
  1434.     REALSelectGraphics(nil);
  1435.     ci = OpenDefaultComponent(StandardCompressionType, StandardCompressionSubTypeSound);
  1436.  
  1437.     SCSetInfo(ci, scSoundSampleRateType, &data->rate);
  1438.     SCSetInfo(ci, scSoundSampleSizeType, &data->sSize);
  1439.     SCSetInfo(ci, scSoundChannelCountType, &data->cCount);
  1440.     SCSetInfo(ci, scSoundCompressionType, &data->compType);
  1441.  
  1442.     err = SCRequestImageSettings(ci);
  1443.  
  1444.     if (err < 0 || err == scUserCancelled)
  1445.     {
  1446.         rv = 0;
  1447.     }
  1448.     else
  1449.     {
  1450.         SCGetInfo(ci, scSoundSampleRateType, &data->rate);
  1451.         SCGetInfo(ci, scSoundSampleSizeType, &data->sSize);
  1452.         SCGetInfo(ci, scSoundChannelCountType, &data->cCount);
  1453.         SCGetInfo(ci, scSoundCompressionType, &data->compType);
  1454.         rv = 1;
  1455.     }
  1456.     CloseComponent(ci);
  1457.     return rv;
  1458. }
  1459.  
  1460. static void soundFormatConstructor(REALobject instance, double rate, int sampleSize, int channelCount, REALstring compression)
  1461. {
  1462.     ClassData(soundFormatClass, instance, SoundFormatData, data);
  1463.  
  1464.     data->rate = rate * 65536.0;
  1465.     data->sSize = sampleSize;
  1466.     data->cCount = channelCount;
  1467.     data->compType = REALstringToOSType(compression);
  1468. }
  1469.  
  1470. static REALobject getSoundConverter(REALobject inputFormat, REALobject outputFormat)
  1471. {
  1472.     ClassData(soundFormatClass, inputFormat, SoundFormatData, inputData);
  1473.     ClassData(soundFormatClass, outputFormat, SoundFormatData, outputData);
  1474.     SoundComponentData inputInfo, outputInfo;
  1475.  
  1476.     inputInfo.flags = 0;
  1477.     inputInfo.format = inputData->compType;
  1478.     inputInfo.numChannels = inputData->cCount;
  1479.     inputInfo.sampleSize = inputData->sSize;
  1480.     inputInfo.sampleRate = inputData->rate;
  1481.     inputInfo.sampleCount = 0;
  1482.     inputInfo.buffer = 0;
  1483.     inputInfo.reserved = 0;
  1484.  
  1485.     outputInfo.flags = 0;
  1486.     outputInfo.format = outputData->compType;
  1487.     outputInfo.numChannels = outputData->cCount;
  1488.     outputInfo.sampleSize = outputData->sSize;
  1489.     outputInfo.sampleRate = outputData->rate;
  1490.     outputInfo.sampleCount = 0;
  1491.     outputInfo.buffer = 0;
  1492.     outputInfo.reserved = 0;
  1493.  
  1494.     SoundConverter sc;
  1495.     if (noErr != SoundConverterOpen(&inputInfo, &outputInfo, &sc))
  1496.         return nil;
  1497.  
  1498.     REALobject rv = REALnewInstance("SoundConverter");
  1499.  
  1500.     ClassData(soundConverterClass, rv, SoundConverterData, data);
  1501.  
  1502.     data->sc = sc;
  1503.  
  1504.     GetCompressionInfo(fixedCompression, inputInfo.format, inputInfo.numChannels, inputInfo.sampleSize, &data->ici);
  1505.     GetCompressionInfo(fixedCompression, outputInfo.format, outputInfo.numChannels, outputInfo.sampleSize, &data->oci);
  1506.     SoundConverterGetBufferSizes(data->sc, 8192, &data->maxInputFrames, &data->inputBytes, &data->outputBytes);
  1507.  
  1508.     return rv;
  1509. }
  1510.  
  1511. static REALstring soundConverterConvert(REALobject instance, REALstring inputData)
  1512. {
  1513.     ClassData(soundConverterClass, instance, SoundConverterData, data);
  1514.     int inputLen, inputOffset, inFrames;
  1515.     Ptr outputBuffer;
  1516.     int dataOffset;
  1517.     unsigned long outFrames, outBytes;
  1518.     int numFrames;
  1519.     Handle hresult;
  1520.     REALstring sResult;
  1521.  
  1522.     numFrames = inputData->Length() / data->ici.bytesPerFrame;
  1523.     outputBuffer = NewPtr(data->outputBytes);
  1524.     hresult = NewHandle(0);
  1525.  
  1526.     SoundConverterBeginConversion(data->sc);
  1527.  
  1528.     inputOffset = 0;
  1529.     while (inputOffset < numFrames)
  1530.     {
  1531.         if ((inputOffset + data->maxInputFrames) > numFrames)
  1532.             inFrames = numFrames - inputOffset;
  1533.         else
  1534.             inFrames = data->maxInputFrames;
  1535.         SoundConverterConvertBuffer(data->sc, inputData->CString() + inputOffset * data->ici.bytesPerFrame, inFrames, outputBuffer, &outFrames, &outBytes);
  1536.         inputOffset += inFrames;
  1537.         PtrAndHand(outputBuffer, hresult, outBytes);
  1538.     }
  1539.     SoundConverterEndConversion(data->sc, outputBuffer, &outFrames, &outBytes);
  1540.     if (outBytes)
  1541.         PtrAndHand(outputBuffer, hresult, outBytes);
  1542.  
  1543.     DisposePtr(outputBuffer);
  1544.  
  1545.     HLock(hresult);
  1546.     sResult = REALBuildString(*hresult, GetHandleSize(hresult));
  1547.     DisposeHandle(hresult);
  1548.     return sResult;
  1549. }
  1550.  
  1551. static REALobject soundSampleFormatGetter(REALsound instance, long param)
  1552. {
  1553.     REALsoundDescription description;
  1554.  
  1555.     REALLockSoundDescription(instance, &description);
  1556.  
  1557.     if (description.soundType == soundMacintoshSnd)
  1558.     {
  1559.         Handle hsound = (Handle) description.soundData;
  1560.         REALobject instance = nil;
  1561.         Byte handleState;
  1562.         unsigned long numFrames, dataOffset;
  1563.         SoundComponentData inputInfo;
  1564.  
  1565.         handleState = HGetState(hsound);
  1566.         HLock(hsound);
  1567.         if (noErr == ParseSndHeader((SndListHandle) description.soundData, &inputInfo, &numFrames, &dataOffset))
  1568.         {
  1569.             instance = REALnewInstance("SoundFormat");
  1570.             ClassData(soundFormatClass, instance, SoundFormatData, data);
  1571.             data->rate = inputInfo.sampleRate;
  1572.             data->sSize = inputInfo.sampleSize;
  1573.             data->cCount = inputInfo.numChannels;
  1574.             data->compType = inputInfo.format;
  1575.         }
  1576.         HSetState(hsound, handleState);
  1577.         return instance;
  1578.     }
  1579.     return nil;
  1580. }
  1581.  
  1582. static REALstring soundSamplesGetter(REALsound instance, long param)
  1583. {
  1584.     REALsoundDescription description;
  1585.  
  1586.     REALLockSoundDescription(instance, &description);
  1587.  
  1588.     if (description.soundType == soundMacintoshSnd)
  1589.     {
  1590.         Handle hsound = (Handle) description.soundData;
  1591.         Byte handleState;
  1592.         unsigned long numFrames, dataOffset;
  1593.         SoundComponentData inputInfo;
  1594.         CompressionInfo ici;
  1595.         REALstring rv = nil;
  1596.  
  1597.         handleState = HGetState(hsound);
  1598.         HLock(hsound);
  1599.         if (noErr == ParseSndHeader((SndListHandle) description.soundData, &inputInfo, &numFrames, &dataOffset))
  1600.         {
  1601.             GetCompressionInfo(fixedCompression, inputInfo.format, inputInfo.numChannels, inputInfo.sampleSize, &ici);
  1602.             rv = REALBuildString(*hsound + dataOffset, ici.bytesPerFrame * numFrames);
  1603.         }
  1604.         HSetState(hsound, handleState);
  1605.         return rv;
  1606.     }
  1607.     return nil;
  1608. }
  1609.  
  1610. /*
  1611. static REALobject newSoundTrack(REALobject instance, int frameRate)
  1612. {
  1613.     ClassData(editableMovieClass, instance, EditableMovieData, data);
  1614.     Track aTrack = NewMovieTrack(data->aMovie, 0, 0, kFullVolume);
  1615.     REALobject rv;
  1616.  
  1617.     if (!aTrack)
  1618.         return nil;
  1619.  
  1620.     Media aMedia = NewTrackMedia(aTrack, SoundMediaType, frameRate, nil, 0);
  1621.  
  1622.     if (!aMedia)
  1623.         return nil;
  1624.  
  1625.     BeginMediaEdits(aMedia);
  1626.  
  1627.     rv = REALnewInstance("QTSoundTrack");
  1628.     if (rv)
  1629.     {
  1630.         ClassData(trackClass, rv, TrackData, trackData);
  1631.         ClassData(soundTrackClass, rv, SoundTrackData, data);
  1632.         trackData->theTrack = aTrack;
  1633.         trackData->movie = instance;
  1634.         REALLockObject(trackData->movie);
  1635.         data->bEdits = true;
  1636.         data->rate = rate22khz;
  1637.         data->sSize = 16;
  1638.         data->cCount = 2;
  1639.         data->compType = kIMACompression;
  1640.     }
  1641.  
  1642.     return rv;
  1643. }
  1644.  
  1645. static void soundTrackAppendSound(REALobject instance, REALsound snd)
  1646. {
  1647.     ClassData(trackClass, instance, TrackData, trackData);
  1648.     ClassData(soundTrackClass, instance, SoundTrackData, data);
  1649.     Media trackMedia = GetTrackMedia(trackData->theTrack);
  1650.     REALsoundDescription description;
  1651.  
  1652.     if (!data->bEdits)
  1653.     {
  1654.         BeginMediaEdits(trackMedia);
  1655.         data->bEdits = true;
  1656.         data->oldDuration = GetMediaDuration(trackMedia);
  1657.  
  1658.         ClassData(editableMovieClass, trackData->movie, EditableMovieData, data);
  1659.         data->bDirty = true;
  1660.     }
  1661.  
  1662.     REALLockSoundDescription(snd, &description);
  1663.  
  1664.     if (description.soundType == soundMacintoshSnd)
  1665.     {
  1666.         SoundComponentData inputInfo, outputInfo;
  1667.         unsigned long numFrames, dataOffset;
  1668.         unsigned long maxInputFrames, inputBytes, outputBytes;
  1669.         CompressionInfo ici, oci;
  1670.         unsigned long inputOffset;
  1671.         Handle hsound = (Handle) description.soundData;
  1672.         Byte handleState;
  1673.         SoundDescriptionHandle sndH;
  1674.  
  1675.         handleState = HGetState(hsound);
  1676.         HLock(hsound);
  1677.         if (noErr == ParseSndHeader((SndListHandle) description.soundData, &inputInfo, &numFrames, &dataOffset))
  1678.         {
  1679.             // inputInfo now holds input format
  1680.  
  1681.             // determine appropriate multiplier for sample size conversion for sound track time scale
  1682.             
  1683.  
  1684.  
  1685.             // set output format to desired output format
  1686.             outputInfo.flags = 0;
  1687.             outputInfo.format = data->compType;
  1688.             outputInfo.numChannels = data->cCount;
  1689.             outputInfo.sampleSize = data->sSize;
  1690.             outputInfo.sampleRate = data->rate;
  1691.             outputInfo.sampleCount = 0;
  1692.             outputInfo.buffer = 0;
  1693.             outputInfo.reserved = 0;
  1694.  
  1695.             // start the conversion
  1696.             SoundConverter sc;
  1697.             if (noErr == SoundConverterOpen(&inputInfo, &outputInfo, &sc))
  1698.             {
  1699.                 Handle outputBuffer;
  1700.                 unsigned long outFrames, outBytes;
  1701.  
  1702.                 SoundConverterGetBufferSizes(sc, 8192, &maxInputFrames, &inputBytes, &outputBytes);
  1703.                 GetCompressionInfo(fixedCompression, inputInfo.format, inputInfo.numChannels, inputInfo.sampleSize, &ici);
  1704.                 GetCompressionInfo(fixedCompression, outputInfo.format, outputInfo.numChannels, outputInfo.sampleSize, &oci);
  1705.  
  1706.                 outputBuffer = NewHandle(outputBytes);
  1707.                 HLock(outputBuffer);
  1708.                 sndH = (SoundDescriptionHandle) NewHandleClear(sizeof(SoundDescription));
  1709.                 HLock((Handle) sndH);
  1710.  
  1711.                 (**sndH).descSize = sizeof(SoundDescription);
  1712.                 (**sndH).dataFormat = outputInfo.format;
  1713.                 (**sndH).numChannels = outputInfo.numChannels;
  1714.                 (**sndH).sampleSize = outputInfo.sampleSize;
  1715.                 (**sndH).sampleRate = outputInfo.sampleRate;
  1716.  
  1717.                 SoundConverterBeginConversion(sc);
  1718.                 inputOffset = 0;
  1719.                 // loop through the frame sets
  1720.                 while (inputOffset < numFrames)
  1721.                 {
  1722.                     unsigned long inFrames = numFrames - inputOffset;
  1723.                     if (inFrames > maxInputFrames)
  1724.                         inFrames = maxInputFrames;
  1725.                     SoundConverterConvertBuffer(sc, (*hsound) + dataOffset + inputOffset * ici.bytesPerFrame, inFrames, *outputBuffer, &outFrames, &outBytes);
  1726.                     AddMediaSample(trackMedia, outputBuffer, 0L, outBytes, (TimeValue)1, (SampleDescriptionHandle)sndH, outBytes / oci.bytesPerPacket * oci.samplesPerPacket, 0, nil);
  1727.                     inputOffset += inFrames;
  1728.                 }
  1729.                 // flush remaining frames
  1730.                 SoundConverterEndConversion(sc, *outputBuffer, &outFrames, &outBytes);
  1731.                 if (outFrames)
  1732.                     AddMediaSample(trackMedia, outputBuffer, 0L, outBytes, (TimeValue)1, (SampleDescriptionHandle)sndH, outBytes / oci.bytesPerPacket * oci.samplesPerPacket, 0, nil);
  1733.                 // dispose of buffers
  1734.                 DisposeHandle(outputBuffer);
  1735.                 DisposeHandle((Handle) sndH);
  1736.             }
  1737.         }
  1738.         HSetState(hsound, handleState);
  1739.     }
  1740.  
  1741.     REALUnlockSoundDescription(snd);
  1742.  
  1743. }
  1744.  
  1745. static int soundTrackSelectCompression(REALobject instance)
  1746. {
  1747.     ClassData(soundTrackClass, instance, SoundTrackData, data);
  1748.     ComponentInstance ci;
  1749.     OSErr err;
  1750.     int rv;
  1751.  
  1752.     REALSelectGraphics(nil);
  1753.     ci = OpenDefaultComponent(StandardCompressionType, StandardCompressionSubTypeSound);
  1754.  
  1755.     SCSetInfo(ci, scSoundSampleRateType, &data->rate);
  1756.     SCSetInfo(ci, scSoundSampleSizeType, &data->sSize);
  1757.     SCSetInfo(ci, scSoundChannelCountType, &data->cCount);
  1758.     SCSetInfo(ci, scSoundCompressionType, &data->compType);
  1759.  
  1760.     err = SCRequestImageSettings(ci);
  1761.  
  1762.     if (err < 0 || err == scUserCancelled)
  1763.     {
  1764.         rv = 0;
  1765.     }
  1766.     else
  1767.     {
  1768.         SCGetInfo(ci, scSoundSampleRateType, &data->rate);
  1769.         SCGetInfo(ci, scSoundSampleSizeType, &data->sSize);
  1770.         SCGetInfo(ci, scSoundChannelCountType, &data->cCount);
  1771.         SCGetInfo(ci, scSoundCompressionType, &data->compType);
  1772.         rv = 1;
  1773.     }
  1774.     CloseComponent(ci);
  1775.     return rv;
  1776. }
  1777. */
  1778. /*
  1779.     Boolean bCodecSelected;
  1780.     short codecDepth;
  1781.     CodecQ codecQuality;
  1782.     CodecQ temporalQuality;
  1783.     CodecType cType;
  1784.     CompressorComponent codec;
  1785.     int keyFrameRate;
  1786.  
  1787.     Boolean bCompressorPrepared;
  1788.     long maxSize;
  1789.     Handle bits;
  1790.     GWorldPtr compressionPage;
  1791.     ImageSequence seq;
  1792.     ImageDescription **imageDescriptionH;
  1793. */
  1794. /*
  1795. REALexport pluginExports[] = {
  1796.     { nil, movieGetPosition },
  1797.     { nil, movieSetPosition },
  1798.     { nil, trackGetDuration },
  1799.     { nil, movieTrackCount },
  1800.     { nil, movieTrack },
  1801.     { nil, trackGetEnabled },
  1802.     { nil, trackSetEnabled },
  1803.     { nil, effectSequenceImageGetter },
  1804.     { nil, getQTSMPTEEffect },
  1805.     { nil, newQTEffectSequence },
  1806.     { nil, qtEffectDestructor },
  1807.     { nil, qtEffectSequenceDestructor },
  1808.     { nil, getQTCrossFadeEffect },
  1809.     { nil, createMovie },
  1810.     { nil, newVideoTrack },
  1811.     { nil, videoTrackAppendPicture },
  1812.     { nil, videoTrackDestructor },
  1813.     { nil, trackDestructor },
  1814.     { nil, videoTrackSelectCompression },
  1815. };
  1816.  
  1817. short pluginExportCode = sizeof(pluginExports) / sizeof(REALexport);
  1818. */
  1819. /*
  1820. struct QTGraphicsExporterData
  1821. {
  1822.     GraphicsExportComponent component;
  1823. };
  1824. */
  1825.  
  1826. static REALobject getQTGraphicsExporter(REALstring format)
  1827. {
  1828.     ComponentInstance ci;
  1829.  
  1830.     if (noErr == OpenADefaultComponent(GraphicsExporterComponentType, REALstringToOSType(format), &ci))
  1831.     {
  1832.         REALobject rv = REALnewInstance("QTGraphicsExporter");    
  1833.         ClassData(qtGraphicsExporterClass, rv, QTGraphicsExporterData, data);
  1834.         data->component = ci;
  1835.         return rv;
  1836.     }
  1837.     else
  1838.         return nil;
  1839. }
  1840.  
  1841. static void graphicsExporterDestructor(REALobject instance, long dummy)
  1842. {
  1843.     ClassData(qtGraphicsExporterClass, instance, QTGraphicsExporterData, data);
  1844.     CloseComponent(data->component);
  1845. }
  1846.  
  1847. static int graphicsExporterRequestSettings(REALobject instance)
  1848. {
  1849.     ClassData(qtGraphicsExporterClass, instance, QTGraphicsExporterData, data);
  1850.  
  1851.     if (noErr == GraphicsExportRequestSettings(data->component, nil, nil))
  1852.         return 1;
  1853.     return 0;
  1854. }
  1855.  
  1856. static int graphicsExporterHasSettingsDialogGetter(REALobject instance, long param)
  1857. {
  1858.     ClassData(qtGraphicsExporterClass, instance, QTGraphicsExporterData, data);
  1859.  
  1860.     if (CallComponentCanDo(data->component, kGraphicsExportRequestSettingsSelect))
  1861.         return 1;
  1862.     return 0;
  1863. }
  1864.  
  1865. static REALstring graphicsExporterDefaultExtensionGetter(REALobject instance, long param)
  1866. {
  1867.     ClassData(qtGraphicsExporterClass, instance, QTGraphicsExporterData, data);
  1868.     OSType extension;
  1869.     const char *sz;
  1870.     int i;
  1871.  
  1872.     if (noErr == GraphicsExportGetDefaultFileNameExtension(data->component, &extension))
  1873.     {
  1874.         sz = (const char *) &extension;
  1875.         for (i = 0; i < 4; i++)
  1876.             if (!sz[i])
  1877.                 break;
  1878.         return REALBuildString(sz, i);
  1879.     }
  1880.     return nil;
  1881. }
  1882.  
  1883. static REALstring graphicsExporterSettingsDescriptionGetter(REALobject instance, long param)
  1884. {
  1885.     return nil;
  1886. }
  1887.  
  1888. static int graphicsExporterSavePicture(REALobject instance, REALfolderItem location, REALpicture image)
  1889. {
  1890.     ClassData(qtGraphicsExporterClass, instance, QTGraphicsExporterData, data);
  1891.     FSSpec spec;
  1892.     REALpictureDescription description;
  1893.     int rv;
  1894.  
  1895.     if (!REALFSSpecFromFolderItem(&spec, location))
  1896.         return 0;
  1897.     if (noErr != GraphicsExportSetOutputFile(data->component, &spec))
  1898.         return 0;
  1899.     REALLockPictureDescription(image, &description);
  1900.     rv = 1;
  1901.     if (description.pictureType == pictureMacintoshPICT)
  1902.     {
  1903.         GraphicsExportSetInputPicture(data->component, (PicHandle) description.pictureData);
  1904.     }
  1905.     else if (description.pictureType == pictureMacintoshGWorld)
  1906.     {
  1907.         GraphicsExportSetInputGWorld(data->component, (GWorldPtr) description.pictureData);
  1908.     }
  1909.     else
  1910.         rv = 0;
  1911.     if (rv)
  1912.     {
  1913.         if (noErr != GraphicsExportDoExport(data->component, nil))
  1914.             rv = 0;
  1915.     }
  1916.     REALUnlockPictureDescription(image);
  1917.     return rv;
  1918. }
  1919.  
  1920. static int graphicsExporterDesiredTargetDataSizeGetter(REALobject instance, long param)
  1921. {
  1922.     ClassData(qtGraphicsExporterClass, instance, QTGraphicsExporterData, data);
  1923.     unsigned long size;
  1924.     if (noErr != GraphicsExportGetTargetDataSize(data->component, &size))
  1925.         return 0;
  1926.     return size;
  1927. }
  1928.  
  1929. static void graphicsExporterDesiredTargetDataSizeSetter(REALobject instance, long param, int value)
  1930. {
  1931.     ClassData(qtGraphicsExporterClass, instance, QTGraphicsExporterData, data);
  1932.     GraphicsExportSetTargetDataSize(data->component, value);
  1933. }
  1934.  
  1935. static int graphicsExporterCompressionQualityGetter(REALobject instance, long param)
  1936. {
  1937.     ClassData(qtGraphicsExporterClass, instance, QTGraphicsExporterData, data);
  1938.     unsigned long quality;
  1939.     if (noErr != GraphicsExportGetCompressionQuality(data->component, &quality))
  1940.         return 0;
  1941.     return quality;
  1942. }
  1943.  
  1944. static void graphicsExporterCompressionQualitySetter(REALobject instance, long param, int value)
  1945. {
  1946.     ClassData(qtGraphicsExporterClass, instance, QTGraphicsExporterData, data);
  1947.     GraphicsExportSetCompressionQuality(data->component, value);
  1948. }
  1949.  
  1950. static REALstring graphicsExporterOutputFileTypeGetter(REALobject instance, long param)
  1951. {
  1952.     ClassData(qtGraphicsExporterClass, instance, QTGraphicsExporterData, data);
  1953.     OSType fileType, fileCreator;
  1954.  
  1955.     GraphicsExportGetOutputFileTypeAndCreator(data->component, &fileType, &fileCreator);
  1956.     return REALBuildString((char *) &fileType, 4);
  1957. }
  1958.  
  1959. static void graphicsExporterOutputFileTypeSetter(REALobject instance, long param, REALstring value)
  1960. {
  1961.     ClassData(qtGraphicsExporterClass, instance, QTGraphicsExporterData, data);
  1962.     OSType fileType, fileCreator;
  1963.  
  1964.     GraphicsExportGetOutputFileTypeAndCreator(data->component, &fileType, &fileCreator);
  1965.     GraphicsExportSetOutputFileTypeAndCreator(data->component, REALstringToOSType(value), fileCreator);
  1966. }
  1967.  
  1968. static REALstring graphicsExporterOutputFileCreatorGetter(REALobject instance, long param)
  1969. {
  1970.     ClassData(qtGraphicsExporterClass, instance, QTGraphicsExporterData, data);
  1971.     OSType fileType, fileCreator;
  1972.  
  1973.     GraphicsExportGetOutputFileTypeAndCreator(data->component, &fileType, &fileCreator);
  1974.     return REALBuildString((char *) &fileCreator, 4);
  1975. }
  1976.  
  1977. static void graphicsExporterOutputFileCreatorSetter(REALobject instance, long param, REALstring value)
  1978. {
  1979.     ClassData(qtGraphicsExporterClass, instance, QTGraphicsExporterData, data);
  1980.     OSType fileType, fileCreator;
  1981.  
  1982.     GraphicsExportGetOutputFileTypeAndCreator(data->component, &fileType, &fileCreator);
  1983.     GraphicsExportSetOutputFileTypeAndCreator(data->component, fileType, REALstringToOSType(value));
  1984. }
  1985.  
  1986. void PluginEntry(void)
  1987. {
  1988.     long result;
  1989.     OSErr error = Gestalt(gestaltQuickTime, &result);
  1990.     if (error == noErr)
  1991.     {
  1992.         if (result >= 0x2100000)
  1993.             gQuicktime21Installed = true;
  1994.         if (result >= 0x3000000)
  1995.             gQuicktime30Installed = true;
  1996.     }
  1997.  
  1998.     REALRegisterClass(&soundFormatClass);
  1999.     REALRegisterClass(&soundConverterClass);
  2000.     REALRegisterClass(&qteffectClass);
  2001.     REALRegisterClass(&qteffectSequenceClass);
  2002.     REALRegisterClass(&qtUserDataClass);
  2003.     REALRegisterClass(&trackClass);
  2004.     REALRegisterClass(&videoTrackClass);
  2005.     REALRegisterClass(&qtGraphicsExporterClass);
  2006. //    REALRegisterClass(&soundTrackClass);
  2007.     REALRegisterClass(&editableMovieClass);
  2008.     REALRegisterClassExtension(&playerExtension);
  2009.     REALRegisterClassExtension(&folderItemExtension);
  2010.     REALRegisterClassExtension(&soundExtension);
  2011.  
  2012.     REALRegisterMethod(&GetQTGraphicsExporterMethod);
  2013.     REALRegisterMethod(&GetQTSMPTEEffectMethod);
  2014.     REALRegisterMethod(&GetQTCrossFadeEffectMethod);
  2015. }
  2016.